home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1997 September / Macworld (1997-09).dmg / Serious Software / Cherwell Scientific Demos / pro Fit / pro Fit 5.0 demo (fpu).sea / pro Fit 5.0 demo (fpu) / External Modules / External modules sources / Pascal / Lissajous.p < prev    next >
Text File  |  1994-09-28  |  6KB  |  204 lines
  1. {************************************************************************************}
  2. {  Lissajous.p                                                                  }
  3. {                                                                           }
  4. {                                                                           }
  5. {  Version 26.9.94                                                      }
  6. {************************************************************************************}
  7.  
  8. unit user;
  9.  
  10.  
  11. interface
  12.  
  13.     uses
  14.         proFit_interface;
  15.  
  16.     procedure main (selector: integer; pb: ExtModulesParamBlockPtr);
  17.  
  18.  
  19.  
  20. implementation
  21.  
  22. { note: MPW users must make sure that the procedure main is at the beginning of the compiled code }
  23. { under Think Pascal, this is cared for by the compiler }
  24. { We let main call a function mainMain to make sure that the code starts with a jump to }
  25. { our entry point even when compiling under MPW Pascal }
  26.  
  27.     procedure mainMain (selector: integer; pb: ExtModulesParamBlockPtr);
  28.     forward;
  29.     procedure main (selector: integer; pb: ExtModulesParamBlockPtr);
  30.  
  31.     begin
  32.         mainMain(selector, pb);
  33.     end;
  34.  
  35.  
  36.  
  37.  
  38.  
  39. {************************************************************************************}
  40.  
  41.     procedure SetUp (var moduleKind: integer;    { set moduleKind to isFunction or isProgram }
  42.                                     var name: Str255;             { the name of the program or function }
  43.                                     var requiredGlobals: longint;     { the number of bytes to be allocated in ExtModulesParamBlock.globals }
  44.                                         { set requiredGlobals to 0 if you don't use this feature }
  45.                                     pb: ExtModulesParamBlockPtr);    { the complete parameter block passed by pro Fit to the }
  46.                                         { routines defined in this file. In most cases it can be ignored }
  47. { SetUp is called once when the external module is linked to pro Fit }
  48.     begin
  49.         moduleKind := isProgram;
  50.         name := 'Lissajous';
  51.         requiredGlobals := 0;
  52.     end;
  53.  
  54.  
  55.  
  56.  
  57. {************************************************************************************}
  58.  
  59.     procedure InitializeProg (pb: ExtModulesParamBlockPtr);
  60. { Can be left emtpy if not needed. }
  61. { called when the external module is linked to proFit after SetUp was called }
  62. { can be used to inititialize global variables, etc. }
  63.     begin
  64.     { initialize default values: }
  65.         pb^.V[1] := 3;                { the frequency along x }
  66.         pb^.V[2] := 4;                { the frequency along y }
  67.         pb^.V[3] := 0.5;            { the step width }
  68.         pb^.V[4] := 500;            { the number of points }
  69.     end;
  70.  
  71.  
  72.  
  73.  
  74. {************************************************************************************}
  75.  
  76.     procedure Run (pb: ExtModulesParamBlockPtr);
  77. { pro Fit calls this function when the name of the program is chosen from the }
  78. { Run Program submenu in the menu Calc }
  79.         var
  80.             s1, s2, s3, s4: str255;            { buffers for input }
  81.             ex1, ex2, ex3, ex4: extended;    { dto }
  82.             r: inputRec;                            { dto }
  83.             i: integer;
  84.             angle: extended;
  85.  
  86.     begin
  87.     { get the parameters from user, for this we prepare the inputRec r }
  88.         ex1 := pb^.v[1];                    { default values are stored in v[..] }
  89.         s1 := 'Frequency x';
  90.         r[1].x := pointer(@ex1);
  91.         r[1].s := pointer(@s1);
  92.         ex2 := pb^.v[2];
  93.         s2 := 'Frequency y';
  94.         r[2].x := pointer(@ex2);
  95.         r[2].s := pointer(@s2);
  96.         ex3 := pb^.v[3];
  97.         s3 := 'Step [rad]';
  98.         r[3].x := pointer(@ex3);
  99.         r[3].s := pointer(@s3);
  100.         ex4 := pb^.v[4];
  101.         s4 := 'Number of points';
  102.         r[4].x := pointer(@ex4);
  103.         r[4].s := pointer(@s4);
  104.         if InputBox(4, r) then
  105.             exit(run);
  106.  
  107.         if ex4 > maxint then                { make sure ex4 can be cast to an integer }
  108.             ex4 := maxint
  109.         else if ex4 < 0 then
  110.             ex4 := 0;
  111.         pb^.v[1] := ex1;                        { defaults for next time }
  112.         pb^.v[2] := ex2;
  113.         pb^.v[3] := ex3;
  114.         pb^.v[4] := ex4;
  115.  
  116.         CreateNewGraf(-1, 1, -1, 1, false, false);    {create a new graph}
  117.  
  118.     { start drawing the curve: }
  119.         newCurve(0.5, 1, 1, 'Lissajous');            { thickness 0.5, no dash, black }
  120.         grMoveto(1, 0);                            { move to the start point }
  121.         angle := 0;
  122.         for i := 1 to round(ex4) do
  123.             begin
  124.                 grLineto(cos(ex1 * angle), sin(ex2 * angle));
  125.                 angle := angle + ex3;
  126.             end; { for i }
  127.  
  128.     end; { run }
  129.  
  130.  
  131.  
  132. {************************************************************************************}
  133.  
  134.     procedure CleanUp (pb: ExtModulesParamBlockPtr);
  135.     { called when the function or program is removed from pro Fit's menus }
  136.     { in most cases, this function can be empty }
  137.     begin
  138.     end;
  139.  
  140.  
  141.  
  142.  
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151. {***********************************************************************************************}
  152.  
  153. { This is the main procedure through which all calls to the external module go.                    }
  154. { Main takes care of calling the right procedure with the right parameters depending on        }
  155. { the value of "selector".                                                                            }
  156. { You don't need to touch this procedure                                                            }
  157.     procedure mainMain (selector: integer; pb: ExtModulesParamBlockPtr);
  158.     begin
  159.         Startup(pb);
  160.         case selector of
  161.             kSetup: 
  162.                 begin
  163.                     pb^.requiredGlobals := 0;
  164.                     pb^.versionNumber := VERSIONNUMBER;
  165.                     if sizeof(extended) = 10 then
  166.                         pb^.codeType := CPU68noFPU
  167.                     else if sizeof(extended) = 12 then
  168.                         pb^.codeType := CPU68FPU
  169.                     else
  170.                         pb^.codeType := CPUPowerPC;
  171.  
  172.                     SetUp(pb^.moduleKind, pb^.name, pb^.requiredGlobals, pb);
  173.                 end;
  174.             progInitialize: 
  175.                 InitializeProg(pb);
  176.             progRun: 
  177.                 Run(pb);
  178.  
  179. {•   funcInitialize: •}
  180. {•    begin•}
  181. {•     pb^.hasDerivatives := false;•}
  182. {•     InitializeFunc(pb^.hasDerivatives, pb^.descr1, pb^.descr2, pb^.numberOfParams, pb^.a0, pb);•}
  183. {•    end;•}
  184. {•   funcCheck: •}
  185. {•    pb^.answer := ord(Check(pb^.paramNo, pb^.a0, pb));•}
  186. {•   funcFirst: •}
  187. {•    First(pb^.a^, pb);•}
  188. {•   funcFunc: •}
  189. {•    Func(pb^.x^, pb^.a^, pb^.y^, pb);•}
  190. {•   funcDerivatives: •}
  191. {•    Derivatives(pb^.x^, pb^.a^, pb^.dyda^, pb);•}
  192. {•   funcLast: •}
  193. {•    Last(pb);•}
  194.  
  195.             kcleanup: 
  196.                 CleanUp(pb);
  197.             otherwise
  198.         end;
  199.     end;
  200.  
  201. {--------------------------------------------------------------------------------------------------------}
  202.  
  203.  
  204. end.